Il formato CSV (Comma-Separated Values) rappresenta uno dei metodi più diffusi e longevi per la rappresentazione e lo scambio di dati strutturati in forma tabellare. La sua origine risale agli albori dell'informatica, quando la necessità di trasferire dati tra sistemi eterogenei richiedeva un formato semplice, leggibile e indipendente dalla piattaforma.
La semplicità apparente del formato CSV nasconde tuttavia diverse sfide implementative che rendono il parsing di questi file un'operazione tutt'altro che banale. Mentre a prima vista un file CSV può sembrare una semplice sequenza di valori separati da virgole, la realtà è che esistono numerose varianti del formato, eccezioni alle regole di base e casi particolari che devono essere gestiti correttamente per garantire l'integrità dei dati.
Un file CSV è essenzialmente un file di testo che rappresenta dati tabellari, dove ogni riga del file corrisponde a un record (tupla) e ogni campo all'interno della riga è separato da un carattere delimitatore. Sebbene il nome suggerisca l'uso della virgola come delimitatore, nella pratica sono utilizzati diversi caratteri separatori a seconda del contesto geografico e applicativo: il punto e virgola nei paesi europei che utilizzano la virgola come separatore decimale, il carattere di tabulazione per i file TSV (Tab-Separated Values), o altri caratteri speciali in contesti particolari.
La struttura di base di un file CSV può essere rappresentata nel seguente modo:
campo1,campo2,campo3,campo4
valore1,valore2,valore3,valore4
valore5,valore6,valore7,valore8
In questo esempio idealizzato, la prima riga contiene gli header (intestazioni di colonna), mentre le righe successive contengono i dati veri e propri. Ogni riga termina con un carattere di fine riga, che può essere un line feed (\n), un carriage return (\r), o la combinazione di entrambi (\r\n), a seconda del sistema operativo di origine del file.
Per comprendere appieno le complessità del parsing CSV, è fondamentale riferirsi alla specifica RFC 4180, pubblicata nell'ottobre 2005, che rappresenta il tentativo più autorevole di standardizzare il formato. Questa specifica definisce le seguenti regole fondamentali:
Innanzitutto, ogni record deve trovarsi su una linea separata, delimitata da un carattere di fine riga (CRLF nella specifica originale). L'ultima riga del file può opzionalmente terminare con un carattere di fine riga. In secondo luogo, è possibile includere una riga di intestazione che compare come prima riga del file, contenente i nomi dei campi con lo stesso formato degli altri record. La presenza di questa riga deve essere dichiarata attraverso il parametro opzionale "header" nel tipo MIME.
Ogni record deve contenere lo stesso numero di campi, garantendo così la coerenza strutturale del file. All'interno di un record, i campi possono essere o meno racchiusi tra doppi apici, secondo necessità. Se un campo non è racchiuso tra doppi apici, i doppi apici non possono apparire all'interno del campo stesso.
I campi che contengono caratteri di fine riga (CRLF), doppi apici, o virgole devono essere obbligatoriamente racchiusi tra doppi apici. Nel caso in cui un campo contenga un carattere doppio apice, questo deve essere preceduto da un altro doppio apice, implementando così una forma di escaping. Infine, gli spazi bianchi sono considerati parte del campo e non devono essere ignorati, a meno che non si trovino all'interno di un campo racchiuso tra doppi apici.
Il parsing di file CSV presenta diverse sfide che vanno ben oltre la semplice separazione di stringhe basata su un delimitatore. La prima e più evidente difficoltà riguarda la gestione dei delimitatori all'interno dei dati. Quando un campo contiene il carattere delimitatore stesso, come nel caso di un indirizzo che include una virgola ("Via Roma, 42"), è necessario un meccanismo per distinguere questo delimitatore-dato dal delimitatore-separatore.
La soluzione standard a questo problema prevede l'uso dei doppi apici per racchiudere i campi che contengono caratteri speciali:
"Nome","Indirizzo","Città"
"Mario Rossi","Via Roma, 42","Milano"
"Luigi Verdi","Piazza Garibaldi 10","Torino"
Questa soluzione introduce però un problema ricorsivo: cosa accade quando un campo contiene sia virgole che doppi apici? La convenzione RFC 4180 prevede che i doppi apici all'interno di un campo racchiuso debbano essere rappresentati da una coppia di doppi apici consecutivi:
"Nome","Citazione"
"Einstein","Disse: ""Dio non gioca a dadi"""
Un'ulteriore complicazione deriva dalla gestione dei caratteri di fine riga all'interno dei campi. Un campo racchiuso tra doppi apici può legittimamente contenere caratteri di newline, creando record che si estendono su più righe fisiche del file. Questo significa che un parser non può semplicemente processare il file riga per riga, ma deve mantenere uno stato che tenga traccia se si trova all'interno di un campo racchiuso o meno.
L'approccio più semplice e intuitivo al parsing CSV consiste nell'utilizzare una funzione di split basata sul carattere delimitatore. In linguaggio C, questo potrebbe essere implementato attraverso la funzione strtok:
char *token = strtok(line, ",");
while (token != NULL) {
// processa il token
token = strtok(NULL, ",");
}
Questo approccio naïve funziona correttamente solo per file CSV molto semplici che non contengono campi racchiusi tra doppi apici, caratteri di fine riga nei dati, o altri casi particolari. Per un parsing robusto è necessario implementare un automa a stati finiti che gestisca correttamente tutte le transizioni possibili.
L'automa deve tracciare almeno i seguenti stati: stato iniziale (inizio di un nuovo campo), stato all'interno di un campo non racchiuso, stato all'interno di un campo racchiuso tra doppi apici, stato dopo aver incontrato un doppio apice all'interno di un campo racchiuso (per distinguere tra doppio apice di chiusura e doppio apice escapato).
Procediamo ora all'implementazione di un parser CSV robusto in linguaggio C. La nostra implementazione dovrà gestire correttamente tutti i casi previsti dalla RFC 4180, mantenendo al contempo efficienza e leggibilità del codice.
Iniziamo definendo le strutture dati necessarie. Avremo bisogno di una struttura per rappresentare un singolo campo, una per rappresentare un record completo, e una per contenere l'intero dataset:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#define INITIAL_FIELD_SIZE 256
#define INITIAL_RECORD_SIZE 16
typedef struct {
char *data;
size_t length;
size_t capacity;
} Field;
typedef struct {
Field *fields;
size_t count;
size_t capacity;
} Record;
typedef struct {
Record *records;
size_t count;
size_t capacity;
} CSVData;
Queste strutture utilizzano array dinamici che crescono secondo necessità, evitando limitazioni arbitrarie sulla dimensione dei dati. La strategia di allocazione dinamica è fondamentale per gestire file CSV di dimensioni variabili senza sprechi di memoria.
Implementiamo ora le funzioni di supporto per la gestione dei campi. La funzione field_init inizializza un nuovo campo con una capacità iniziale, mentre field_append aggiunge caratteri al campo, riallocando la memoria quando necessario:
void field_init(Field *field) {
field->capacity = INITIAL_FIELD_SIZE;
field->data = malloc(field->capacity);
field->length = 0;
if (field->data != NULL) {
field->data[0] = '\0';
}
}
bool field_append(Field *field, char c) {
if (field->length + 2 > field->capacity) {
size_t new_capacity = field->capacity * 2;
char *new_data = realloc(field->data, new_capacity);
if (new_data == NULL) {
return false;
}
field->data = new_data;
field->capacity = new_capacity;
}
field->data[field->length++] = c;
field->data[field->length] = '\0';
return true;
}
void field_free(Field *field) {
free(field->data);
field->data = NULL;
field->length = 0;
field->capacity = 0;
}
La strategia di raddoppiare la capacità quando si esaurisce lo spazio garantisce un costo ammortizzato costante per l'inserimento di caratteri, risultando in una complessità temporale O(n) per la costruzione di un campo di lunghezza n.
Similmente, implementiamo le funzioni per la gestione dei record:
void record_init(Record *record) {
record->capacity = INITIAL_RECORD_SIZE;
record->fields = malloc(record->capacity * sizeof(Field));
record->count = 0;
}
bool record_add_field(Record *record, Field field) {
if (record->count >= record->capacity) {
size_t new_capacity = record->capacity * 2;
Field *new_fields = realloc(record->fields,
new_capacity * sizeof(Field));
if (new_fields == NULL) {
return false;
}
record->fields = new_fields;
record->capacity = new_capacity;
}
record->fields[record->count++] = field;
return true;
}
void record_free(Record *record) {
for (size_t i = 0; i < record->count; i++) {
field_free(&record->fields[i]);
}
free(record->fields);
record->fields = NULL;
record->count = 0;
}
Il cuore dell'implementazione risiede nella funzione di parsing vera e propria. Utilizzeremo un automa a stati finiti per gestire correttamente tutte le transizioni possibili:
typedef enum {
STATE_FIELD_START,
STATE_IN_FIELD,
STATE_IN_QUOTED_FIELD,
STATE_QUOTE_IN_QUOTED_FIELD,
STATE_RECORD_END
} ParserState;
bool parse_csv_line(const char *line, Record *record, char delimiter) {
ParserState state = STATE_FIELD_START;
Field current_field;
field_init(¤t_field);
const char *p = line;
while (*p != '\0' && *p != '\n' && *p != '\r') {
char c = *p;
switch (state) {
case STATE_FIELD_START:
if (c == '"') {
state = STATE_IN_QUOTED_FIELD;
} else if (c == delimiter) {
// Campo vuoto
if (!record_add_field(record, current_field)) {
field_free(¤t_field);
return false;
}
field_init(¤t_field);
} else {
field_append(¤t_field, c);
state = STATE_IN_FIELD;
}
break;
case STATE_IN_FIELD:
if (c == delimiter) {
if (!record_add_field(record, current_field)) {
field_free(¤t_field);
return false;
}
field_init(¤t_field);
state = STATE_FIELD_START;
} else {
field_append(¤t_field, c);
}
break;
case STATE_IN_QUOTED_FIELD:
if (c == '"') {
state = STATE_QUOTE_IN_QUOTED_FIELD;
} else {
field_append(¤t_field, c);
}
break;
case STATE_QUOTE_IN_QUOTED_FIELD:
if (c == '"') {
// Doppio apice escapato
field_append(¤t_field, '"');
state = STATE_IN_QUOTED_FIELD;
} else if (c == delimiter) {
if (!record_add_field(record, current_field)) {
field_free(¤t_field);
return false;
}
field_init(¤t_field);
state = STATE_FIELD_START;
} else {
// Carattere dopo la chiusura del campo racchiuso
// Secondo RFC 4180 questo è un errore, ma possiamo
// essere tolleranti e ignorare il carattere
state = STATE_IN_FIELD;
}
break;
case STATE_RECORD_END:
break;
}
p++;
}
// Aggiungi l'ultimo campo
if (!record_add_field(record, current_field)) {
field_free(¤t_field);
return false;
}
return true;
}
Questa implementazione dell'automa gestisce correttamente tutte le transizioni di stato definite dalla RFC 4180. Ogni carattere letto causa una transizione di stato che determina come il carattere stesso debba essere processato. Lo stato STATE_QUOTE_IN_QUOTED_FIELD è particolarmente importante perché permette di distinguere tra un doppio apice che chiude un campo e un doppio apice escapato che fa parte del contenuto del campo.
Una complicazione ulteriore nel parsing CSV deriva dalla possibilità che i campi racchiusi tra doppi apici contengano caratteri di fine riga. In questo caso, un singolo record logico si estende su più righe fisiche del file. Per gestire correttamente questa situazione, è necessario leggere il file carattere per carattere o implementare un buffer che accumuli più righe fisiche finché il record logico non è completo:
bool parse_csv_file(FILE *file, CSVData *csv_data, char delimiter) {
char *line = NULL;
size_t line_capacity = 0;
ssize_t line_length;
bool in_quoted_field = false;
char *accumulated_line = NULL;
size_t accumulated_capacity = 0;
size_t accumulated_length = 0;
while ((line_length = getline(&line, &line_capacity, file)) != -1) {
// Controlla se siamo all'interno di un campo racchiuso
for (ssize_t i = 0; i < line_length; i++) {
if (line[i] == '"') {
// Conta i doppi apici consecutivi
int quote_count = 1;
while (i + quote_count < line_length &&
line[i + quote_count] == '"') {
quote_count++;
}
// Se il numero di apici è dispari, cambia stato
if (quote_count % 2 == 1) {
in_quoted_field = !in_quoted_field;
}
i += quote_count - 1;
}
}
// Accumula la riga
if (accumulated_line == NULL) {
accumulated_capacity = line_length + 1;
accumulated_line = malloc(accumulated_capacity);
accumulated_length = 0;
}
if (accumulated_length + line_length >= accumulated_capacity) {
accumulated_capacity = (accumulated_length + line_length + 1) * 2;
accumulated_line = realloc(accumulated_line, accumulated_capacity);
}
memcpy(accumulated_line + accumulated_length, line, line_length);
accumulated_length += line_length;
accumulated_line[accumulated_length] = '\0';
// Se non siamo in un campo racchiuso, processa il record
if (!in_quoted_field) {
Record record;
record_init(&record);
if (parse_csv_line(accumulated_line, &record, delimiter)) {
// Aggiungi il record ai dati CSV
if (csv_data->count >= csv_data->capacity) {
csv_data->capacity *= 2;
csv_data->records = realloc(csv_data->records,
csv_data->capacity * sizeof(Record));
}
csv_data->records[csv_data->count++] = record;
}
free(accumulated_line);
accumulated_line = NULL;
accumulated_length = 0;
}
}
free(line);
free(accumulated_line);
return true;
}
Questa implementazione mantiene un buffer che accumula righe fisiche finché non viene completato un record logico, identificato dalla condizione di non essere all'interno di un campo racchiuso tra doppi apici alla fine della riga.
Il parsing di file CSV può diventare un collo di bottiglia prestazionale quando si lavora con file di grandi dimensioni. Esistono diverse strategie di ottimizzazione che possono migliorare significativamente le prestazioni del parser.
Una prima ottimizzazione consiste nell'utilizzare buffer di lettura più grandi. La funzione getline è comoda ma può non essere ottimale per file molto grandi. L'uso di fread con buffer di dimensioni appropriate (tipicamente 4KB o 8KB) può ridurre significativamente il numero di chiamate di sistema, migliorando le prestazioni complessive.
Una seconda ottimizzazione riguarda l'allocazione della memoria. La strategia di raddoppiare la capacità quando necessario è buona, ma per file di cui si conosce a priori la struttura, può essere vantaggioso pre-allocare la memoria necessaria. Inoltre, l'uso di memory pool per l'allocazione dei campi può ridurre la frammentazione della memoria e migliorare la località dei riferimenti.
Per file estremamente grandi, può essere necessario implementare un parsing incrementale o streaming, in cui i record vengono processati uno alla volta senza caricare l'intero file in memoria. Questo approccio è particolarmente importante quando si lavora con file che superano la memoria disponibile.
Un parser robusto deve non solo leggere correttamente i dati, ma anche rilevare e segnalare errori nel formato del file. Gli errori più comuni includono: campi non chiusi correttamente (doppi apici di apertura senza corrispondente chiusura), numero inconsistente di campi tra i record, caratteri non validi secondo la codifica dichiarata, record incompleti alla fine del file.
La gestione degli errori può essere implementata attraverso un sistema di codici di errore e messaggi descrittivi che indichino la posizione esatta dell'errore nel file, facilitando il debugging:
typedef enum {
CSV_OK = 0,
CSV_ERROR_MEMORY,
CSV_ERROR_UNCLOSED_QUOTE,
CSV_ERROR_INCONSISTENT_FIELDS,
CSV_ERROR_INVALID_CHARACTER,
CSV_ERROR_IO
} CSVError;
typedef struct {
CSVError code;
size_t line;
size_t column;
char message[256];
} CSVParseError;
Oltre al formato standard definito dalla RFC 4180, esistono numerose varianti e estensioni del formato CSV che un parser completo dovrebbe essere in grado di gestire. Alcune di queste includono: diversi caratteri delimitatori (punto e virgola, tabulazione, pipe), diversi caratteri di escape (backslash invece del doppio doppio apice), supporto per commenti (righe che iniziano con caratteri speciali come #), encoding multipli (UTF-8, Latin-1, ecc.), compressione (file CSV compressi con gzip o altri algoritmi).
Un parser configurabile dovrebbe permettere di specificare questi parametri attraverso una struttura di configurazione:
typedef struct {
char delimiter;
char quote_char;
char escape_char;
bool has_header;
bool skip_empty_lines;
char comment_char;
const char *encoding;
} CSVConfig;
Il parsing di file CSV rappresenta un problema apparentemente semplice che rivela complessità considerevoli quando si affrontano casi reali. Un'implementazione corretta richiede attenzione ai dettagli, gestione accurata dello stato, e robustezza nella gestione degli errori.
Le best practices per l'implementazione di un parser CSV includono: seguire rigorosamente la RFC 4180 quando possibile, essere tolleranti nell'input quando si gestiscono file prodotti da altri sistemi, validare sempre la consistenza dei dati, documentare chiaramente le assunzioni e le limitazioni del parser, fornire messaggi di errore chiari e informativi, testare il parser con una varietà di casi limite e file malformati.
Per applicazioni di produzione, è spesso consigliabile utilizzare librerie mature e ben testate piuttosto che implementare un parser da zero. Librerie come libcsv in C o i moduli CSV inclusi nei linguaggi di alto livello hanno gestito migliaia di casi particolari e sono state ottimizzate per le prestazioni. Tuttavia, comprendere i principi del parsing CSV e implementare un parser basilare è un eccellente esercizio per comprendere i concetti di parsing, gestione dello stato, e processamento di dati strutturati.
Python offre nella sua libreria standard il modulo csv, introdotto nella versione 2.3 e successivamente raffinato nelle versioni successive. Questo modulo rappresenta un esempio paradigmatico di come un linguaggio di alto livello possa astrarre la complessità del parsing CSV, fornendo un'interfaccia elegante e pythonica che nasconde le complessità implementative discusse nel capitolo precedente.
Il modulo csv è implementato in C per garantire prestazioni ottimali, ma espone un'API Python che si integra perfettamente con gli idiomi del linguaggio. La presenza di questo modulo nella libreria standard sottolinea l'importanza del formato CSV nell'ecosistema Python, particolarmente nel contesto dell'analisi dati e del data science.
Il modulo csv si basa su due classi fondamentali che implementano pattern di design complementari: csv.reader per la lettura e csv.writer per la scrittura di file CSV. Queste classi implementano il pattern Iterator, permettendo di processare file CSV in modo lazy, ovvero caricando in memoria un record alla volta anziché l'intero file.
Questa caratteristica è fondamentale quando si lavora con file di grandi dimensioni, in quanto permette di elaborare dataset che superano la memoria disponibile. Il modulo utilizza inoltre il pattern Strategy attraverso i "dialects", permettendo di configurare il comportamento del parser per adattarsi a diverse varianti del formato CSV.
L'utilizzo più semplice del modulo csv prevede l'apertura di un file e la creazione di un oggetto reader che itera sui record:
import csv
with open('dati.csv', 'r', encoding='utf-8', newline='') as file:
reader = csv.reader(file)
for row in reader:
print(row)
Questo frammento di codice merita un'analisi dettagliata di ogni suo elemento. L'uso del context manager with garantisce la corretta chiusura del file anche in presenza di eccezioni, seguendo il principio RAII (Resource Acquisition Is Initialization). Il parametro encoding='utf-8' specifica esplicitamente la codifica dei caratteri, evitando ambiguità che potrebbero causare errori di decodifica. Il parametro newline='' è particolarmente importante: disabilita la traduzione universale dei caratteri di fine riga, delegando completamente la gestione delle newline al modulo csv che implementa correttamente la RFC 4180.
L'oggetto reader è un iteratore che restituisce ogni riga del file come una lista di stringhe. È importante notare che csv.reader non effettua alcuna conversione di tipo: tutti i valori sono restituiti come stringhe, indipendentemente dal loro contenuto apparente. La conversione dei tipi deve essere gestita esplicitamente dal programmatore.
Mentre csv.reader restituisce liste generiche, la classe csv.DictReader offre un'interfaccia più semantica restituendo ogni record come un dizionario ordinato dove le chiavi sono i nomi delle colonne:
import csv
with open('studenti.csv', 'r', encoding='utf-8', newline='') as file:
reader = csv.DictReader(file)
for row in reader:
print(f"Nome: {row['nome']}, Cognome: {row['cognome']}, "
f"Matricola: {row['matricola']}")
Questa classe presuppone che la prima riga del file contenga gli header delle colonne. Se il file non ha una riga di intestazione, è possibile specificare i nomi dei campi esplicitamente attraverso il parametro fieldnames:
fieldnames = ['nome', 'cognome', 'matricola', 'voto']
reader = csv.DictReader(file, fieldnames=fieldnames)
L'utilizzo di DictReader presenta vantaggi significativi in termini di leggibilità e manutenibilità del codice. L'accesso ai campi per nome anziché per indice numerico rende il codice autoesplicativo e resistente a modifiche nell'ordine delle colonne. Inoltre, facilita la validazione dei dati attraverso il controllo dell'esistenza delle chiavi attese.
Il concetto di "dialect" nel modulo csv rappresenta un insieme di parametri che definiscono una particolare variante del formato CSV. I dialect predefiniti includono excel, excel-tab, e unix, ciascuno configurato per corrispondere al formato prodotto da specifici software:
import csv
# Registrazione di un dialect personalizzato
csv.register_dialect('semicolon',
delimiter=';',
quotechar='"',
doublequote=True,
skipinitialspace=True,
lineterminator='\r\n',
quoting=csv.QUOTE_MINIMAL)
with open('dati_europei.csv', 'r', encoding='utf-8', newline='') as file:
reader = csv.reader(file, dialect='semicolon')
for row in reader:
process_row(row)
I parametri principali di un dialect sono i seguenti. Il delimiter specifica il carattere utilizzato per separare i campi, tipicamente virgola, punto e virgola, o tabulazione. Il quotechar definisce il carattere utilizzato per racchiudere i campi che contengono caratteri speciali. Il parametro doublequote controlla come vengono escapati i caratteri quote all'interno dei campi racchiusi: se True, un quote viene escapato raddoppiandolo, se False, viene utilizzato il carattere specificato da escapechar.
Il skipinitialspace determina se gli spazi bianchi immediatamente dopo il delimitatore debbano essere ignorati. Il lineterminator specifica la sequenza di caratteri utilizzata per terminare le righe. Il parametro quoting controlla quando i campi devono essere racchiusi tra quote: QUOTE_MINIMAL racchiude solo i campi che contengono caratteri speciali, QUOTE_ALL racchiude tutti i campi, QUOTE_NONNUMERIC racchiude tutti i campi non numerici, QUOTE_NONE non racchiude mai i campi e richiede un carattere di escape.
Il modulo csv può sollevare diverse eccezioni durante il parsing. La più comune è csv.Error, una classe di eccezione specifica per errori legati al formato CSV. Una gestione robusta degli errori dovrebbe catturare queste eccezioni e fornire informazioni diagnostiche utili:
import csv
import sys
def parse_csv_with_error_handling(filename):
records = []
errors = []
try:
with open(filename, 'r', encoding='utf-8', newline='') as file:
reader = csv.reader(file)
line_num = 0
for row in reader:
line_num += 1
try:
# Validazione del numero di campi
if line_num == 1:
expected_fields = len(row)
elif len(row) != expected_fields:
raise csv.Error(
f"Record con numero errato di campi: "
f"attesi {expected_fields}, trovati {len(row)}"
)
records.append(row)
except csv.Error as e:
errors.append({
'line': line_num,
'error': str(e),
'row': row
})
except FileNotFoundError:
print(f"File {filename} non trovato", file=sys.stderr)
return None, None
except UnicodeDecodeError as e:
print(f"Errore di decodifica: {e}", file=sys.stderr)
return None, None
return records, errors
Questa implementazione separa gli errori a livello di file (file non trovato, errori di encoding) dagli errori a livello di record (formato non valido, numero di campi inconsistente), permettendo una gestione granulare delle diverse situazioni di errore.
Il modulo csv fornisce simmetricamente le classi csv.writer e csv.DictWriter per la scrittura di file CSV:
import csv
# Scrittura con csv.writer
data = [
['nome', 'cognome', 'età', 'città'],
['Mario', 'Rossi', '30', 'Milano'],
['Luigi', 'Verdi', '25', 'Roma'],
['Anna', 'Bianchi', '28', 'Torino']
]
with open('output.csv', 'w', encoding='utf-8', newline='') as file:
writer = csv.writer(file)
writer.writerows(data)
Per una scrittura più strutturata con DictWriter:
import csv
fieldnames = ['nome', 'cognome', 'età', 'città']
data = [
{'nome': 'Mario', 'cognome': 'Rossi', 'età': 30, 'città': 'Milano'},
{'nome': 'Luigi', 'cognome': 'Verdi', 'età': 25, 'città': 'Roma'},
{'nome': 'Anna', 'cognome': 'Bianchi', 'età': 28, 'città': 'Torino'}
]
with open('output_dict.csv', 'w', encoding='utf-8', newline='') as file:
writer = csv.DictWriter(file, fieldnames=fieldnames)
writer.writeheader()
writer.writerows(data)
Il metodo writeheader() scrive automaticamente la riga di intestazione con i nomi dei campi. DictWriter offre il vantaggio di validare implicitamente che tutti i dizionari contengano le chiavi specificate in fieldnames, sollevando un'eccezione se una chiave richiesta è assente.
Come menzionato, csv.reader restituisce tutti i valori come stringhe. Per applicazioni reali è spesso necessario convertire i valori nei tipi appropriati. Una strategia elegante consiste nell'utilizzare un mapping di funzioni di conversione:
import csv
from datetime import datetime
from decimal import Decimal
def parse_typed_csv(filename, type_converters):
"""
Legge un CSV applicando conversioni di tipo specificate.
Args:
filename: percorso del file CSV
type_converters: dizionario {campo: funzione_conversione}
Returns:
Lista di dizionari con valori convertiti
"""
records = []
with open(filename, 'r', encoding='utf-8', newline='') as file:
reader = csv.DictReader(file)
for row in reader:
converted_row = {}
for field, value in row.items():
if field in type_converters and value.strip():
try:
converted_row[field] = type_converters[field](value)
except (ValueError, TypeError) as e:
print(f"Errore conversione campo '{field}': {e}")
converted_row[field] = value
else:
converted_row[field] = value
records.append(converted_row)
return records
# Esempio d'uso
converters = {
'età': int,
'stipendio': Decimal,
'data_assunzione': lambda x: datetime.strptime(x, '%Y-%m-%d'),
'attivo': lambda x: x.lower() in ('true', '1', 'yes', 'si')
}
data = parse_typed_csv('dipendenti.csv', converters)
Questa implementazione permette di specificare funzioni di conversione arbitrarie per ogni campo, gestendo anche valori vuoti e errori di conversione in modo graceful. L'uso di lambda functions per conversioni personalizzate offre grande flessibilità.
Quando si lavora con file CSV di dimensioni significative, è fondamentale utilizzare un approccio streaming che non carichi l'intero file in memoria. Python facilita questo attraverso la natura iterativa di csv.reader:
import csv
from collections import defaultdict
def compute_statistics_streaming(filename, value_column, group_column):
"""
Calcola statistiche aggregate su un file CSV grande senza
caricarlo interamente in memoria.
"""
stats = defaultdict(lambda: {
'count': 0,
'sum': 0,
'min': float('inf'),
'max': float('-inf')
})
with open(filename, 'r', encoding='utf-8', newline='') as file:
reader = csv.DictReader(file)
for row in reader:
try:
group = row[group_column]
value = float(row[value_column])
stats[group]['count'] += 1
stats[group]['sum'] += value
stats[group]['min'] = min(stats[group]['min'], value)
stats[group]['max'] = max(stats[group]['max'], value)
except (ValueError, KeyError) as e:
continue
# Calcola medie
for group in stats:
stats[group]['mean'] = stats[group]['sum'] / stats[group]['count']
return dict(stats)
# Esempio: calcola statistiche di vendita per regione
vendite_stats = compute_statistics_streaming(
'vendite_2024.csv',
value_column='importo',
group_column='regione'
)
Questo pattern è estremamente efficiente perché mantiene in memoria solo i dati aggregati, non i record individuali. Può processare file di gigabyte con un footprint di memoria costante.
Per analisi dati più complesse, l'integrazione con la libreria pandas rappresenta il gold standard nell'ecosistema Python. Pandas offre la funzione read_csv che estende significativamente le capacità del modulo csv standard:
import pandas as pd
# Lettura base
df = pd.read_csv('dati.csv', encoding='utf-8')
# Lettura avanzata con parsing automatico dei tipi
df = pd.read_csv('dati_complessi.csv',
encoding='utf-8',
sep=';', # Delimitatore personalizzato
decimal=',', # Separatore decimale
thousands='.', # Separatore migliaia
parse_dates=['data'], # Parsing automatico date
dtype={'codice': str, # Tipi espliciti
'quantità': int,
'prezzo': float},
na_values=['N/A', 'NULL'], # Valori da considerare NA
skipinitialspace=True, # Ignora spazi dopo delimitatore
skip_blank_lines=True, # Salta righe vuote
comment='#', # Ignora commenti
nrows=10000, # Limita numero di righe
usecols=['nome', 'prezzo'], # Seleziona solo alcune colonne
converters={'codice': lambda x: x.upper()}) # Conversioni custom
Pandas gestisce automaticamente molte delle complessità che richiederebbero codice manuale con il modulo csv standard: inferenza automatica dei tipi, parsing di date e datetime, gestione di valori mancanti, ottimizzazione della memoria attraverso tipi categorici, chunking automatico per file grandi.
Per file estremamente grandi, pandas supporta la lettura iterativa attraverso il parametro chunksize:
import pandas as pd
chunk_size = 10000
chunks = []
for chunk in pd.read_csv('file_enorme.csv', chunksize=chunk_size):
# Elabora ogni chunk
filtered_chunk = chunk[chunk['valore'] > 100]
chunks.append(filtered_chunk)
# Combina i risultati
result = pd.concat(chunks, ignore_index=True)
Nonostante l'eccellenza del modulo csv standard, esistono situazioni in cui può essere necessario implementare un parser personalizzato. Questo può essere il caso quando si devono gestire varianti non standard del formato o quando si richiedono ottimizzazioni specifiche. Implementiamo un parser CSV in Python puro che dimostri i principi fondamentali:
from enum import Enum, auto
from typing import List, Iterator, Optional
from dataclasses import dataclass
class ParseState(Enum):
"""Stati dell'automa a stati finiti per il parsing CSV."""
FIELD_START = auto()
IN_FIELD = auto()
IN_QUOTED_FIELD = auto()
QUOTE_IN_QUOTED_FIELD = auto()
@dataclass
class CSVConfig:
"""Configurazione del parser CSV."""
delimiter: str = ','
quotechar: str = '"'
escapechar: Optional[str] = None
doublequote: bool = True
skipinitialspace: bool = False
lineterminator: str = '\n'
class CSVParser:
"""Parser CSV implementato come automa a stati finiti."""
def __init__(self, config: CSVConfig = None):
self.config = config or CSVConfig()
def parse_line(self, line: str) -> List[str]:
"""
Parsa una singola riga CSV restituendo una lista di campi.
Implementa un automa a stati finiti che gestisce correttamente
campi racchiusi tra quote, escape sequences, e delimitatori
all'interno dei dati.
"""
fields = []
current_field = []
state = ParseState.FIELD_START
i = 0
while i < len(line):
char = line[i]
if state == ParseState.FIELD_START:
if self.config.skipinitialspace and char == ' ':
i += 1
continue
elif char == self.config.quotechar:
state = ParseState.IN_QUOTED_FIELD
elif char == self.config.delimiter:
fields.append('')
state = ParseState.FIELD_START
elif char in ('\r', '\n'):
break
else:
current_field.append(char)
state = ParseState.IN_FIELD
elif state == ParseState.IN_FIELD:
if char == self.config.delimiter:
fields.append(''.join(current_field))
current_field = []
state = ParseState.FIELD_START
elif char in ('\r', '\n'):
break
else:
current_field.append(char)
elif state == ParseState.IN_QUOTED_FIELD:
if char == self.config.quotechar:
state = ParseState.QUOTE_IN_QUOTED_FIELD
else:
current_field.append(char)
elif state == ParseState.QUOTE_IN_QUOTED_FIELD:
if char == self.config.quotechar and self.config.doublequote:
# Doppio quote escapato
current_field.append(self.config.quotechar)
state = ParseState.IN_QUOTED_FIELD
elif char == self.config.delimiter:
fields.append(''.join(current_field))
current_field = []
state = ParseState.FIELD_START
elif char in ('\r', '\n'):
break
else:
# Carattere dopo la chiusura del campo quotato
# RFC 4180 considera questo un errore, ma siamo tolleranti
current_field.append(char)
state = ParseState.IN_FIELD
i += 1
# Aggiungi l'ultimo campo
fields.append(''.join(current_field))
return fields
def parse_file(self, filename: str, encoding: str = 'utf-8') -> Iterator[List[str]]:
"""
Parsa un intero file CSV, gestendo correttamente record multi-riga.
Yields:
Lista di campi per ogni record
"""
with open(filename, 'r', encoding=encoding, newline='') as file:
accumulated_line = []
in_quoted_field = False
for line in file:
# Determina se siamo all'interno di un campo quotato
quote_count = line.count(self.config.quotechar)
# Sottrai le quote escapate
if self.config.doublequote:
escaped_quotes = line.count(self.config.quotechar * 2)
quote_count -= escaped_quotes
if quote_count % 2 == 1:
in_quoted_field = not in_quoted_field
accumulated_line.append(line)
if not in_quoted_field:
# Record completo
full_line = ''.join(accumulated_line)
fields = self.parse_line(full_line)
yield fields
accumulated_line = []
Questa implementazione dimostra i principi fondamentali del parsing CSV in Python, utilizzando pattern moderni come dataclass per la configurazione, enum per gli stati, e type hints per la chiarezza. L'uso di un generator (yield) per parse_file garantisce un utilizzo efficiente della memoria.
Un aspetto critico nel parsing CSV è la validazione dei dati. Python offre eccellenti strumenti per implementare pipeline di validazione robuste:
from typing import Any, Callable, Dict, List, Tuple
from dataclasses import dataclass
from enum import Enum
import re
class ValidationSeverity(Enum):
"""Livelli di severità per errori di validazione."""
ERROR = 'error'
WARNING = 'warning'
INFO = 'info'
@dataclass
class ValidationError:
"""Rappresenta un errore di validazione."""
line: int
field: str
value: Any
message: str
severity: ValidationSeverity
class CSVValidator:
"""Framework per validazione strutturata di dati CSV."""
def __init__(self):
self.validators: Dict[str, List[Callable]] = {}
self.errors: List[ValidationError] = []
def add_validator(self, field: str, validator: Callable[[Any], Tuple[bool, str]]):
"""
Aggiunge un validatore per un campo specifico.
Args:
field: nome del campo da validare
validator: funzione che ritorna (is_valid, error_message)
"""
if field not in self.validators:
self.validators[field] = []
self.validators[field].append(validator)
def validate_record(self, record: Dict[str, Any], line_num: int) -> bool:
"""
Valida un singolo record.
Returns:
True se il record è valido, False altrimenti
"""
is_valid = True
for field, validators in self.validators.items():
if field not in record:
self.errors.append(ValidationError(
line=line_num,
field=field,
value=None,
message=f"Campo obbligatorio '{field}' mancante",
severity=ValidationSeverity.ERROR
))
is_valid = False
continue
value = record[field]
for validator in validators:
valid, message = validator(value)
if not valid:
self.errors.append(ValidationError(
line=line_num,
field=field,
value=value,
message=message,
severity=ValidationSeverity.ERROR
))
is_valid = False
return is_valid
def get_errors(self) -> List[ValidationError]:
"""Restituisce tutti gli errori di validazione."""
return self.errors
def clear_errors(self):
"""Pulisce la lista degli errori."""
self.errors = []
# Esempio di validatori predefiniti
def not_empty(value: str) -> Tuple[bool, str]:
"""Valida che il campo non sia vuoto."""
if not value or not value.strip():
return False, "Il campo non può essere vuoto"
return True, ""
def is_email(value: str) -> Tuple[bool, str]:
"""Valida formato email."""
pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
if not re.match(pattern, value):
return False, f"'{value}' non è un indirizzo email valido"
return True, ""
def is_in_range(min_val: float, max_val: float) -> Callable:
"""Factory per validatore di range numerico."""
def validator(value: str) -> Tuple[bool, str]:
try:
num = float(value)
if num < min_val or num > max_val:
return False, f"Valore {num} fuori range [{min_val}, {max_val}]"
return True, ""
except ValueError:
return False, f"'{value}' non è un numero valido"
return validator
def matches_pattern(pattern: str) -> Callable:
"""Factory per validatore basato su regex."""
compiled = re.compile(pattern)
def validator(value: str) -> Tuple[bool, str]:
if not compiled.match(value):
return False, f"'{value}' non rispetta il pattern richiesto"
return True, ""
return validator
# Esempio d'uso completo
def validate_csv_file(filename: str) -> Tuple[List[Dict], List[ValidationError]]:
"""
Valida un file CSV e restituisce record validi ed errori.
"""
validator = CSVValidator()
# Configura validatori
validator.add_validator('email', not_empty)
validator.add_validator('email', is_email)
validator.add_validator('età', is_in_range(18, 120))
validator.add_validator('codice_fiscale',
matches_pattern(r'^[A-Z]{6}\d{2}[A-Z]\d{2}[A-Z]\d{3}[A-Z]$'))
valid_records = []
with open(filename, 'r', encoding='utf-8', newline='') as file:
reader = csv.DictReader(file)
for line_num, record in enumerate(reader, start=2): # start=2 per header
if validator.validate_record(record, line_num):
valid_records.append(record)
return valid_records, validator.get_errors()
Questo framework di validazione è estensibile, componibile, e fornisce diagnostiche dettagliate su tutti gli errori riscontrati. L'uso di factory functions per i validatori parametrici (is_in_range, matches_pattern) dimostra pattern avanzati di programmazione funzionale in Python.
Per applicazioni che richiedono prestazioni estreme, è possibile implementare parti critiche del parser in Cython, ottenendo velocità comparabili a C mantenendo la sintassi Python:
# csv_parser_fast.pyx
cimport cython
from libc.stdlib cimport malloc, free
from libc.string cimport strlen, strcpy
@cython.boundscheck(False)
@cython.wraparound(False)
def parse_csv_line_fast(str line, str delimiter):
"""
Parser CSV ottimizzato con Cython.
Questa versione elimina i controlli dei bounds e utilizza
operazioni a livello C per massimizzare le prestazioni.
"""
cdef:
list fields = []
str current_field = ""
int in_quotes = 0
char* c_line = <bytes>line.encode('utf-8')
int i, length = len(line)
for i in range(length):
if c_line[i] == ord('"'):
in_quotes = 1 - in_quotes
elif c_line[i] == ord(delimiter[0]) and not in_quotes:
fields.append(current_field)
current_field = ""
else:
current_field += chr(c_line[i])
fields.append(current_field)
return fields
La compilazione con Cython può fornire speedup da 2x a 10x rispetto a Python puro, particolarmente per file con molte righe di poche colonne.
L'ecosistema Python per il parsing CSV offre un continuum di soluzioni che vanno dal modulo csv standard, semplice ma potente, a librerie specializzate come pandas per analisi dati complesse, fino a implementazioni custom ottimizzate per casi d'uso specifici. La scelta dello strumento appropriato dipende dai requisiti specifici: dimensione dei file, complessità del formato, necessità di validazione, requisiti prestazionali.
Il modulo csv standard rappresenta un eccellente punto di partenza per la maggior parte delle applicazioni, offrendo un buon bilanciamento tra semplicità d'uso e robustezza. Per analisi dati più complesse, pandas è lo standard de facto e offre capacità estremamente avanzate. Per requisiti prestazionali estremi o formati altamente non standard, un parser personalizzato, possibilmente ottimizzato con Cython, può essere la soluzione ottimale.
La comprensione profonda dei principi di parsing CSV discussi in questo e nel precedente capitolo permette di fare scelte informate e di implementare soluzioni robuste ed efficienti per qualsiasi scenario applicativo.
Java, con la sua natura fortemente tipizzata e orientata agli oggetti, offre un approccio al parsing CSV significativamente diverso rispetto a C e Python. Mentre C richiede gestione manuale della memoria e Python privilegia la semplicità e la flessibilità, Java enfatizza la type safety, l'incapsulamento e la robustezza attraverso il suo sistema di eccezioni checked e unchecked.
L'ecosistema Java per il parsing CSV si è evoluto nel corso degli anni, partendo da implementazioni manuali utilizzando String.split(), passando per soluzioni custom che implementano l'RFC 4180, fino ad arrivare a librerie mature e ampiamente adottate come Apache Commons CSV, OpenCSV e Jackson CSV. Questa evoluzione riflette la maturazione della comprensione delle complessità del formato CSV nella comunità Java.
L'approccio più immediato che un programmatore Java potrebbe adottare per il parsing CSV consiste nell'utilizzo del metodo split() della classe String:
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class SimpleCSVParser {
public static List<String[]> parseCSV(String filename) throws IOException {
List<String[]> records = new ArrayList<>();
try (BufferedReader reader = new BufferedReader(new FileReader(filename))) {
String line;
while ((line = reader.readLine()) != null) {
String[] fields = line.split(",");
records.add(fields);
}
}
return records;
}
public static void main(String[] args) {
try {
List<String[]> data = parseCSV("dati.csv");
for (String[] record : data) {
for (String field : record) {
System.out.print(field + " | ");
}
System.out.println();
}
} catch (IOException e) {
System.err.println("Errore nella lettura del file: " + e.getMessage());
}
}
}
Questa implementazione, sebbene funzionale per CSV estremamente semplici, presenta numerose limitazioni critiche. Non gestisce campi racchiusi tra doppi apici che contengono virgole, non supporta caratteri di newline all'interno dei campi, non gestisce l'escaping dei doppi apici, e tratta tutti i valori come stringhe senza possibilità di conversione automatica dei tipi.
Il metodo split() utilizza espressioni regolari, il che introduce un overhead non necessario per il semplice splitting su un carattere fisso. Inoltre, non c'è gestione degli errori oltre alle eccezioni di I/O, rendendo impossibile identificare e recuperare da record malformati.
Per comprendere appieno le sfide del parsing CSV in Java, implementiamo un parser che rispetta completamente l'RFC 4180, utilizzando un automa a stati finiti simile a quello implementato in C e Python:
import java.io.*;
import java.util.*;
/**
* Parser CSV RFC 4180 compliant implementato come automa a stati finiti.
* Gestisce correttamente campi quoted, escape sequences, e record multi-riga.
*/
public class RFC4180CSVParser {
/**
* Stati dell'automa a stati finiti per il parsing CSV.
*/
private enum ParseState {
FIELD_START,
IN_FIELD,
IN_QUOTED_FIELD,
QUOTE_IN_QUOTED_FIELD,
RECORD_END
}
/**
* Configurazione del parser CSV.
*/
public static class CSVConfig {
private final char delimiter;
private final char quoteChar;
private final boolean doubleQuote;
private final boolean skipInitialSpace;
private final String encoding;
public CSVConfig(char delimiter, char quoteChar, boolean doubleQuote,
boolean skipInitialSpace, String encoding) {
this.delimiter = delimiter;
this.quoteChar = quoteChar;
this.doubleQuote = doubleQuote;
this.skipInitialSpace = skipInitialSpace;
this.encoding = encoding;
}
/**
* Configurazione predefinita conforme a RFC 4180.
*/
public static CSVConfig defaultConfig() {
return new CSVConfig(',', '"', true, false, "UTF-8");
}
/**
* Configurazione per file CSV europei (delimiter punto e virgola).
*/
public static CSVConfig europeanConfig() {
return new CSVConfig(';', '"', true, true, "UTF-8");
}
// Getters
public char getDelimiter() { return delimiter; }
public char getQuoteChar() { return quoteChar; }
public boolean isDoubleQuote() { return doubleQuote; }
public boolean isSkipInitialSpace() { return skipInitialSpace; }
public String getEncoding() { return encoding; }
}
/**
* Eccezione custom per errori di parsing CSV.
*/
public static class CSVParseException extends Exception {
private final int lineNumber;
private final int columnNumber;
public CSVParseException(String message, int lineNumber, int columnNumber) {
super(String.format("Errore parsing CSV alla riga %d, colonna %d: %s",
lineNumber, columnNumber, message));
this.lineNumber = lineNumber;
this.columnNumber = columnNumber;
}
public int getLineNumber() { return lineNumber; }
public int getColumnNumber() { return columnNumber; }
}
private final CSVConfig config;
public RFC4180CSVParser(CSVConfig config) {
this.config = config;
}
public RFC4180CSVParser() {
this(CSVConfig.defaultConfig());
}
/**
* Parsa una singola riga CSV restituendo una lista di campi.
*
* @param line la riga da parsare
* @return lista di campi estratti
* @throws CSVParseException se la riga non è ben formata
*/
public List<String> parseLine(String line) throws CSVParseException {
List<String> fields = new ArrayList<>();
StringBuilder currentField = new StringBuilder();
ParseState state = ParseState.FIELD_START;
int i = 0;
int lineNumber = 1; // Potrebbe essere passato come parametro
while (i < line.length()) {
char c = line.charAt(i);
switch (state) {
case FIELD_START:
if (config.skipInitialSpace && c == ' ') {
i++;
continue;
} else if (c == config.quoteChar) {
state = ParseState.IN_QUOTED_FIELD;
} else if (c == config.delimiter) {
// Campo vuoto
fields.add("");
state = ParseState.FIELD_START;
} else if (c == '\r' || c == '\n') {
// Fine riga
break;
} else {
currentField.append(c);
state = ParseState.IN_FIELD;
}
break;
case IN_FIELD:
if (c == config.delimiter) {
fields.add(currentField.toString());
currentField = new StringBuilder();
state = ParseState.FIELD_START;
} else if (c == '\r' || c == '\n') {
// Fine riga
break;
} else {
currentField.append(c);
}
break;
case IN_QUOTED_FIELD:
if (c == config.quoteChar) {
state = ParseState.QUOTE_IN_QUOTED_FIELD;
} else {
currentField.append(c);
}
break;
case QUOTE_IN_QUOTED_FIELD:
if (c == config.quoteChar && config.doubleQuote) {
// Doppio quote escapato
currentField.append(config.quoteChar);
state = ParseState.IN_QUOTED_FIELD;
} else if (c == config.delimiter) {
fields.add(currentField.toString());
currentField = new StringBuilder();
state = ParseState.FIELD_START;
} else if (c == '\r' || c == '\n') {
// Fine riga dopo campo quoted
break;
} else {
// RFC 4180 considera questo un errore, ma siamo tolleranti
currentField.append(c);
state = ParseState.IN_FIELD;
}
break;
case RECORD_END:
break;
}
i++;
}
// Aggiungi l'ultimo campo
fields.add(currentField.toString());
// Verifica che non ci siano campi quoted non chiusi
if (state == ParseState.IN_QUOTED_FIELD) {
throw new CSVParseException("Campo quoted non chiuso", lineNumber, i);
}
return fields;
}
/**
* Parsa un intero file CSV, gestendo record multi-riga.
*
* @param filename percorso del file da parsare
* @return lista di record (ogni record è una lista di campi)
* @throws IOException in caso di errori di I/O
* @throws CSVParseException in caso di errori di parsing
*/
public List<List<String>> parseFile(String filename)
throws IOException, CSVParseException {
List<List<String>> records = new ArrayList<>();
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(new FileInputStream(filename),
config.encoding))) {
StringBuilder accumulatedLine = new StringBuilder();
String line;
int lineNumber = 0;
boolean inQuotedField = false;
while ((line = reader.readLine()) != null) {
lineNumber++;
// Determina se siamo all'interno di un campo quoted
// contando i quote non escapati
int quoteCount = 0;
for (int i = 0; i < line.length(); i++) {
if (line.charAt(i) == config.quoteChar) {
// Verifica se è escapato
if (config.doubleQuote && i + 1 < line.length() &&
line.charAt(i + 1) == config.quoteChar) {
i++; // Salta il prossimo quote
} else {
quoteCount++;
}
}
}
if (quoteCount % 2 == 1) {
inQuotedField = !inQuotedField;
}
accumulatedLine.append(line);
if (!inQuotedField) {
// Record completo
List<String> fields = parseLine(accumulatedLine.toString());
records.add(fields);
accumulatedLine = new StringBuilder();
} else {
// Aggiungi newline per preservare i caratteri di fine riga
// all'interno dei campi quoted
accumulatedLine.append('\n');
}
}
// Verifica che non ci siano record incompleti
if (inQuotedField) {
throw new CSVParseException("File termina con campo quoted non chiuso",
lineNumber, 0);
}
}
return records;
}
}
Questa implementazione dimostra diversi pattern avanzati di Java: l'uso di enum per rappresentare gli stati dell'automa garantisce type safety e leggibilità, le classi annidate statiche (CSVConfig, CSVParseException) organizzano logicamente il codice correlato, il pattern Builder attraverso i factory methods (defaultConfig(), europeanConfig()) fornisce configurazioni predefinite, e il try-with-resources garantisce la corretta chiusura delle risorse anche in presenza di eccezioni.
Apache Commons CSV rappresenta la libreria di riferimento nell'ecosistema Java per il parsing CSV. Sviluppata e mantenuta dalla Apache Software Foundation, offre un'API elegante, prestazioni ottimizzate, e supporto completo per l'RFC 4180 e diverse varianti del formato.
Per utilizzare Apache Commons CSV, aggiungiamo la dipendenza Maven:
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-csv</artifactId>
<version>1.10.0</version>
</dependency>
L'utilizzo base della libreria è estremamente intuitivo:
import org.apache.commons.csv.*;
import java.io.*;
import java.util.*;
public class ApacheCSVExample {
/**
* Lettura semplice di un file CSV.
*/
public static void simpleRead(String filename) throws IOException {
try (Reader in = new FileReader(filename);
CSVParser parser = CSVFormat.DEFAULT.parse(in)) {
for (CSVRecord record : parser) {
for (String field : record) {
System.out.print(field + " | ");
}
System.out.println();
}
}
}
/**
* Lettura con header per accesso nominale ai campi.
*/
public static void readWithHeaders(String filename) throws IOException {
try (Reader in = new FileReader(filename);
CSVParser parser = CSVFormat.DEFAULT
.withFirstRecordAsHeader()
.parse(in)) {
for (CSVRecord record : parser) {
String nome = record.get("nome");
String cognome = record.get("cognome");
String email = record.get("email");
System.out.printf("Nome: %s, Cognome: %s, Email: %s%n",
nome, cognome, email);
}
}
}
/**
* Configurazione avanzata con formato personalizzato.
*/
public static void advancedConfiguration(String filename) throws IOException {
CSVFormat format = CSVFormat.Builder.create()
.setDelimiter(';')
.setQuote('"')
.setRecordSeparator("\r\n")
.setIgnoreEmptyLines(true)
.setTrim(true)
.setNullString("NULL")
.setCommentMarker('#')
.setHeader("nome", "cognome", "età", "città")
.setSkipHeaderRecord(true)
.build();
try (Reader in = new FileReader(filename);
CSVParser parser = format.parse(in)) {
for (CSVRecord record : parser) {
// Accesso sicuro con gestione valori null
String nome = record.get("nome");
String età = record.get("età");
if (età != null) {
int etaInt = Integer.parseInt(età);
System.out.printf("%s ha %d anni%n", nome, etaInt);
}
}
}
}
/**
* Lettura di CSV con mapping automatico su oggetti.
*/
public static class Persona {
private String nome;
private String cognome;
private int età;
private String città;
// Costruttori, getters, setters
public Persona() {}
public Persona(String nome, String cognome, int età, String città) {
this.nome = nome;
this.cognome = cognome;
this.età = età;
this.città = città;
}
// Getters e setters omessi per brevità
public String getNome() { return nome; }
public void setNome(String nome) { this.nome = nome; }
public String getCognome() { return cognome; }
public void setCognome(String cognome) { this.cognome = cognome; }
public int getEtà() { return età; }
public void setEtà(int età) { this.età = età; }
public String getCittà() { return città; }
public void setCittà(String città) { this.città = città; }
@Override
public String toString() {
return String.format("Persona{nome='%s', cognome='%s', età=%d, città='%s'}",
nome, cognome, età, città);
}
}
public static List<Persona> readToObjects(String filename) throws IOException {
List<Persona> persone = new ArrayList<>();
try (Reader in = new FileReader(filename);
CSVParser parser = CSVFormat.DEFAULT
.withFirstRecordAsHeader()
.parse(in)) {
for (CSVRecord record : parser) {
Persona persona = new Persona(
record.get("nome"),
record.get("cognome"),
Integer.parseInt(record.get("età")),
record.get("città")
);
persone.add(persona);
}
}
return persone;
}
/**
* Scrittura di file CSV con Apache Commons CSV.
*/
public static void writeCSV(String filename, List<Persona> persone)
throws IOException {
try (Writer out = new FileWriter(filename);
CSVPrinter printer = CSVFormat.DEFAULT
.withHeader("nome", "cognome", "età", "città")
.print(out)) {
for (Persona persona : persone) {
printer.printRecord(
persona.getNome(),
persona.getCognome(),
persona.getEtà(),
persona.getCittà()
);
}
}
}
/**
* Esempio completo con gestione errori.
*/
public static void completeExample(String inputFile, String outputFile) {
try {
// Leggi persone dal file
List<Persona> persone = readToObjects(inputFile);
// Filtra persone (esempio: solo maggiorenni)
List<Persona> maggiorenni = new ArrayList<>();
for (Persona p : persone) {
if (p.getEtà() >= 18) {
maggiorenni.add(p);
}
}
// Scrivi risultati
writeCSV(outputFile, maggiorenni);
System.out.printf("Processate %d persone, %d maggiorenni%n",
persone.size(), maggiorenni.size());
} catch (IOException e) {
System.err.println("Errore I/O: " + e.getMessage());
e.printStackTrace();
} catch (NumberFormatException e) {
System.err.println("Errore conversione numero: " + e.getMessage());
} catch (IllegalArgumentException e) {
System.err.println("Campo mancante o non valido: " + e.getMessage());
}
}
}
Apache Commons CSV offre diversi vantaggi significativi rispetto a un'implementazione custom: supporto nativo per tutti i formati standard (Excel, RFC 4180, MySQL, TDF), API fluente e type-safe attraverso il pattern Builder, gestione robusta di casi limite ed edge cases, ottimizzazioni prestazionali a livello di implementazione, e ampia documentazione e supporto della comunità.
OpenCSV è un'altra libreria popolare che offre un'API leggermente diversa, particolarmente utile per il mapping automatico su bean Java attraverso annotazioni:
import com.opencsv.*;
import com.opencsv.bean.*;
import java.io.*;
import java.util.List;
public class OpenCSVExample {
/**
* Classe con annotazioni per mapping automatico.
*/
public static class Studente {
@CsvBindByName(column = "matricola")
private String matricola;
@CsvBindByName(column = "nome")
private String nome;
@CsvBindByName(column = "cognome")
private String cognome;
@CsvBindByName(column = "voto")
private double voto;
@CsvDate("yyyy-MM-dd")
@CsvBindByName(column = "data_iscrizione")
private java.util.Date dataIscrizione;
// Costruttori, getters, setters
public Studente() {}
public String getMatricola() { return matricola; }
public void setMatricola(String matricola) { this.matricola = matricola; }
public String getNome() { return nome; }
public void setNome(String nome) { this.nome = nome; }
public String getCognome() { return cognome; }
public void setCognome(String cognome) { this.cognome = cognome; }
public double getVoto() { return voto; }
public void setVoto(double voto) { this.voto = voto; }
public java.util.Date getDataIscrizione() { return dataIscrizione; }
public void setDataIscrizione(java.util.Date data) {
this.dataIscrizione = data;
}
@Override
public String toString() {
return String.format("Studente{matricola='%s', nome='%s', cognome='%s', " +
"voto=%.2f, dataIscrizione=%s}",
matricola, nome, cognome, voto, dataIscrizione);
}
}
/**
* Lettura con mapping automatico su bean.
*/
public static List<Studente> readStudentiWithMapping(String filename)
throws IOException {
try (Reader reader = new FileReader(filename)) {
CsvToBean<Studente> csvToBean = new CsvToBeanBuilder<Studente>(reader)
.withType(Studente.class)
.withIgnoreLeadingWhiteSpace(true)
.withIgnoreEmptyLine(true)
.build();
return csvToBean.parse();
}
}
/**
* Lettura con strategia di mapping personalizzata.
*/
public static List<Studente> readWithCustomStrategy(String filename)
throws IOException {
try (Reader reader = new FileReader(filename)) {
HeaderColumnNameMappingStrategy<Studente> strategy =
new HeaderColumnNameMappingStrategy<>();
strategy.setType(Studente.class);
CsvToBean<Studente> csvToBean = new CsvToBeanBuilder<Studente>(reader)
.withMappingStrategy(strategy)
.withIgnoreLeadingWhiteSpace(true)
.build();
return csvToBean.parse();
}
}
/**
* Scrittura con mapping automatico da bean.
*/
public static void writeStudenti(String filename, List<Studente> studenti)
throws IOException {
try (Writer writer = new FileWriter(filename)) {
StatefulBeanToCsv<Studente> beanToCsv =
new StatefulBeanToCsvBuilder<Studente>(writer)
.withQuotechar(CSVWriter.DEFAULT_QUOTE_CHARACTER)
.withSeparator(CSVWriter.DEFAULT_SEPARATOR)
.build();
beanToCsv.write(studenti);
}
}
/**
* Gestione avanzata con validazione custom.
*/
public static class StudenteValidator implements CsvToBeanFilter {
@Override
public boolean allowLine(String[] line) {
// Salta righe vuote o con meno di 5 campi
if (line == null || line.length < 5) {
return false;
}
// Verifica che il voto sia valido
try {
double voto = Double.parseDouble(line[3]);
return voto >= 0 && voto <= 30;
} catch (NumberFormatException e) {
return false;
}
}
}
public static List<Studente> readWithValidation(String filename)
throws IOException {
try (Reader reader = new FileReader(filename)) {
CsvToBean<Studente> csvToBean = new CsvToBeanBuilder<Studente>(reader)
.withType(Studente.class)
.withFilter(new StudenteValidator())
.withThrowExceptions(false)
.build();
List<Studente> studenti = csvToBean.parse();
// Gestisci eventuali errori di parsing
List<CsvException> capturedExceptions = csvToBean.getCapturedExceptions();
if (!capturedExceptions.isEmpty()) {
System.err.println("Errori durante il parsing:");
for (CsvException e : capturedExceptions) {
System.err.printf("Riga %d: %s%n",
e.getLineNumber(), e.getMessage());
}
}
return studenti;
}
}
/**
* Configurazione personalizzata del parser.
*/
public static List<Studente> readWithCustomParser(String filename)
throws IOException {
// Crea parser custom
CSVParser parser = new CSVParserBuilder()
.withSeparator(';')
.withQuoteChar('"')
.withEscapeChar('\\')
.withStrictQuotes(false)
.withIgnoreLeadingWhiteSpace(true)
.build();
try (Reader reader = new FileReader(filename)) {
CSVReader csvReader = new CSVReaderBuilder(reader)
.withCSVParser(parser)
.withSkipLines(1) // Salta header se già gestito
.build();
CsvToBean<Studente> csvToBean = new CsvToBeanBuilder<Studente>(reader)
.withType(Studente.class)
.build();
return csvToBean.parse();
}
}
}
OpenCSV eccelle nel binding automatico tra CSV e oggetti Java attraverso annotazioni, riducendo significativamente il boilerplate code necessario per il mapping dei dati. Le annotazioni @CsvBindByName e @CsvDate permettono di dichiarare il mapping in modo declarativo, aumentando la leggibilità e la manutenibilità del codice.
Java 8 ha introdotto le Streams API che si integrano elegantemente con il parsing CSV, permettendo di scrivere pipeline di elaborazione dati concise ed espressive:
import org.apache.commons.csv.*;
import java.io.*;
import java.util.*;
import java.util.stream.*;
public class CSVStreamProcessing {
public static class Transazione {
private final String id;
private final String data;
private final double importo;
private final String categoria;
public Transazione(String id, String data, double importo, String categoria) {
this.id = id;
this.data = data;
this.importo = importo;
this.categoria = categoria;
}
public String getId() { return id; }
public String getData() { return data; }
public double getImporto() { return importo; }
public String getCategoria() { return categoria; }
}
/**
* Elaborazione funzionale di file CSV usando Streams.
*/
public static Map<String, Double> analizzaTransazioni(String filename)
throws IOException {
try (Reader in = new FileReader(filename);
CSVParser parser = CSVFormat.DEFAULT
.withFirstRecordAsHeader()
.parse(in)) {
// Converti CSVRecord in Transazione e calcola totale per categoria
return StreamSupport.stream(parser.spliterator(), false)
.map(record -> new Transazione(
record.get("id"),
record.get("data"),
Double.parseDouble(record.get("importo")),
record.get("categoria")
))
.collect(Collectors.groupingBy(
Transazione::getCategoria,
Collectors.summingDouble(Transazione::getImporto)
));
}
}
/**
* Pipeline complessa con filtraggio, mapping e aggregazione.
*/
public static class StatisticheTransazioni {
private final String categoria;
private final long count;
private final double totale;
private final double media;
private final double min;
private final double max;
public StatisticheTransazioni(String categoria, long count,
double totale, double media,
double min, double max) {
this.categoria = categoria;
this.count = count;
this.totale = totale;
this.media = media;
this.min = min;
this.max = max;
}
@Override
public String toString() {
return String.format(
"Categoria: %s, Transazioni: %d, Totale: %.2f€, " +
"Media: %.2f€, Min: %.2f€, Max: %.2f€",
categoria, count, totale, media, min, max
);
}
}
public static List<StatisticheTransazioni> calcolaStatistiche(String filename)
throws IOException {
try (Reader in = new FileReader(filename);
CSVParser parser = CSVFormat.DEFAULT
.withFirstRecordAsHeader()
.parse(in)) {
Map<String, DoubleSummaryStatistics> statsPerCategoria =
StreamSupport.stream(parser.spliterator(), false)
.map(record -> new Transazione(
record.get("id"),
record.get("data"),
Double.parseDouble(record.get("importo")),
record.get("categoria")
))
.filter(t -> t.getImporto() > 0) // Solo transazioni positive
.collect(Collectors.groupingBy(
Transazione::getCategoria,
Collectors.summarizingDouble(Transazione::getImporto)
));
return statsPerCategoria.entrySet().stream()
.map(entry -> new StatisticheTransazioni(
entry.getKey(),
entry.getValue().getCount(),
entry.getValue().getSum(),
entry.getValue().getAverage(),
entry.getValue().getMin(),
entry.getValue().getMax()
))
.sorted(Comparator.comparing(s -> -s.totale)) // Ordina per totale desc
.collect(Collectors.toList());
}
}
/**
* Processing parallelo per file grandi.
*/
public static Map<String, Long> conteggioParallelo(String filename)
throws IOException {
try (Reader in = new FileReader(filename);
CSVParser parser = CSVFormat.DEFAULT
.withFirstRecordAsHeader()
.parse(in)) {
return StreamSupport.stream(parser.spliterator(), true) // parallel=true
.map(record -> record.get("categoria"))
.collect(Collectors.groupingByConcurrent(
categoria -> categoria,
Collectors.counting()
));
}
}
/**
* Lazy evaluation con Stream infiniti per file molto grandi.
*/
public static void processBigFileChunked(String filename, int chunkSize)
throws IOException {
try (Reader in = new FileReader(filename);
CSVParser parser = CSVFormat.DEFAULT
.withFirstRecordAsHeader()
.parse(in)) {
Iterator<CSVRecord> iterator = parser.iterator();
// Processa in chunk
while (iterator.hasNext()) {
List<Transazione> chunk = Stream.generate(() -> null)
.limit(chunkSize)
.takeWhile(x -> iterator.hasNext())
.map(x -> {
CSVRecord record = iterator.next();
return new Transazione(
record.get("id"),
record.get("data"),
Double.parseDouble(record.get("importo")),
record.get("categoria")
);
})
.collect(Collectors.toList());
// Elabora il chunk
processChunk(chunk);
}
}
}
private static void processChunk(List<Transazione> chunk) {
// Elaborazione del chunk
double totale = chunk.stream()
.mapToDouble(Transazione::getImporto)
.sum();
System.out.printf("Chunk di %d transazioni, totale: %.2f€%n",
chunk.size(), totale);
}
}
L'uso delle Streams API trasforma il parsing CSV da operazione imperativa a dichiarativa, rendendo il codice più conciso e spesso più performante grazie all'ottimizzazione automatica e alla possibilità di parallelizzazione.
In contesti enterprise, è comune incapsulare la logica di parsing CSV in pattern architetturali come Repository e Data Transfer Object (DTO):
import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;
/**
* Data Transfer Object per trasferimento dati studente.
*/
public class StudenteDTO {
private final String matricola;
private final String nome;
private final String cognome;
private final double mediaVoti;
public StudenteDTO(String matricola, String nome, String cognome, double mediaVoti) {
this.matricola = Objects.requireNonNull(matricola, "Matricola non può essere null");
this.nome = Objects.requireNonNull(nome, "Nome non può essere null");
this.cognome = Objects.requireNonNull(cognome, "Cognome non può essere null");
if (mediaVoti < 0 || mediaVoti > 30) {
throw new IllegalArgumentException("Media voti deve essere tra 0 e 30");
}
this.mediaVoti = mediaVoti;
}
public String getMatricola() { return matricola; }
public String getNome() { return nome; }
public String getCognome() { return cognome; }
public double getMediaVoti() { return mediaVoti; }
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
StudenteDTO that = (StudenteDTO) o;
return matricola.equals(that.matricola);
}
@Override
public int hashCode() {
return Objects.hash(matricola);
}
}
/**
* Repository per accesso ai dati studenti da sorgente CSV.
*/
public interface StudenteRepository {
List<StudenteDTO> findAll() throws IOException;
Optional<StudenteDTO> findByMatricola(String matricola) throws IOException;
List<StudenteDTO> findByMediaVotiGreaterThan(double soglia) throws IOException;
void save(StudenteDTO studente) throws IOException;
void saveAll(List<StudenteDTO> studenti) throws IOException;
}
/**
* Implementazione del repository usando Apache Commons CSV.
*/
public class StudenteCSVRepository implements StudenteRepository {
private final String csvFilePath;
private final CSVFormat csvFormat;
public StudenteCSVRepository(String csvFilePath) {
this.csvFilePath = csvFilePath;
this.csvFormat = CSVFormat.DEFAULT
.withFirstRecordAsHeader()
.withHeader("matricola", "nome", "cognome", "media_voti");
}
@Override
public List<StudenteDTO> findAll() throws IOException {
try (Reader in = new FileReader(csvFilePath);
CSVParser parser = csvFormat.parse(in)) {
return StreamSupport.stream(parser.spliterator(), false)
.map(this::recordToDTO)
.collect(Collectors.toList());
}
}
@Override
public Optional<StudenteDTO> findByMatricola(String matricola) throws IOException {
return findAll().stream()
.filter(s -> s.getMatricola().equals(matricola))
.findFirst();
}
@Override
public List<StudenteDTO> findByMediaVotiGreaterThan(double soglia) throws IOException {
return findAll().stream()
.filter(s -> s.getMediaVoti() > soglia)
.collect(Collectors.toList());
}
@Override
public void save(StudenteDTO studente) throws IOException {
List<StudenteDTO> tutti = findAll();
// Rimuovi vecchia versione se esiste
tutti.removeIf(s -> s.getMatricola().equals(studente.getMatricola()));
// Aggiungi nuovo studente
tutti.add(studente);
// Riscrivi file
saveAll(tutti);
}
@Override
public void saveAll(List<StudenteDTO> studenti) throws IOException {
try (Writer out = new FileWriter(csvFilePath);
CSVPrinter printer = csvFormat.print(out)) {
for (StudenteDTO studente : studenti) {
printer.printRecord(
studente.getMatricola(),
studente.getNome(),
studente.getCognome(),
studente.getMediaVoti()
);
}
}
}
private StudenteDTO recordToDTO(CSVRecord record) {
try {
return new StudenteDTO(
record.get("matricola"),
record.get("nome"),
record.get("cognome"),
Double.parseDouble(record.get("media_voti"))
);
} catch (IllegalArgumentException e) {
throw new IllegalStateException(
"Errore conversione record alla riga " + record.getRecordNumber(), e
);
}
}
}
/**
* Service layer che utilizza il repository.
*/
public class StudenteService {
private final StudenteRepository repository;
public StudenteService(StudenteRepository repository) {
this.repository = Objects.requireNonNull(repository);
}
public List<StudenteDTO> getStudentiEccellenti() throws IOException {
return repository.findByMediaVotiGreaterThan(27.0);
}
public Map<String, Long> getDistribuzionePerFasciaVoti() throws IOException {
return repository.findAll().stream()
.collect(Collectors.groupingBy(
this::determinaFascia,
Collectors.counting()
));
}
private String determinaFascia(StudenteDTO studente) {
double media = studente.getMediaVoti();
if (media >= 27) return "Eccellente";
if (media >= 24) return "Buono";
if (media >= 21) return "Discreto";
return "Sufficiente";
}
public void promuoviStudente(String matricola, double nuovaMedia) throws IOException {
Optional<StudenteDTO> studenteOpt = repository.findByMatricola(matricola);
if (studenteOpt.isEmpty()) {
throw new IllegalArgumentException("Studente non trovato: " + matricola);
}
StudenteDTO studente = studenteOpt.get();
StudenteDTO aggiornato = new StudenteDTO(
studente.getMatricola(),
studente.getNome(),
studente.getCognome(),
nuovaMedia
);
repository.save(aggiornato);
}
}
/**
* Esempio di utilizzo con dependency injection.
*/
public class ApplicationExample {
public static void main(String[] args) {
try {
// Setup
StudenteRepository repository = new StudenteCSVRepository("studenti.csv");
StudenteService service = new StudenteService(repository);
// Business logic
List<StudenteDTO> eccellenti = service.getStudentiEccellenti();
System.out.println("Studenti eccellenti: " + eccellenti.size());
Map<String, Long> distribuzione = service.getDistribuzionePerFasciaVoti();
distribuzione.forEach((fascia, count) ->
System.out.printf("%s: %d studenti%n", fascia, count)
);
// Modifica dati
service.promuoviStudente("12345", 28.5);
} catch (IOException e) {
System.err.println("Errore I/O: " + e.getMessage());
e.printStackTrace();
} catch (IllegalArgumentException e) {
System.err.println("Errore business logic: " + e.getMessage());
}
}
}
Questo pattern architetturale separa chiaramente le responsabilità: il DTO rappresenta i dati, il Repository gestisce la persistenza, e il Service implementa la business logic. Questa separazione facilita il testing, la manutenibilità e l'evoluzione del codice.
Il testing del parsing CSV richiede particolare attenzione ai casi limite ed edge cases. JUnit 5 e AssertJ offrono un framework robusto per test completi:
import org.junit.jupiter.api.*;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.ValueSource;
import static org.assertj.core.api.Assertions.*;
import java.io.*;
import java.nio.file.*;
import java.util.List;
public class CSVParserTest {
private Path tempDir;
private RFC4180CSVParser parser;
@BeforeEach
void setUp() throws IOException {
tempDir = Files.createTempDirectory("csv-test");
parser = new RFC4180CSVParser();
}
@AfterEach
void tearDown() throws IOException {
Files.walk(tempDir)
.sorted(Comparator.reverseOrder())
.forEach(path -> {
try {
Files.delete(path);
} catch (IOException e) {
// Ignora errori di cleanup
}
});
}
@Test
@DisplayName("Parsing di CSV semplice senza quote")
void testSimpleCSV() throws Exception {
String csv = "nome,cognome,età\nMario,Rossi,30\nLuigi,Verdi,25";
List<String> firstLine = parser.parseLine("nome,cognome,età");
assertThat(firstLine)
.hasSize(3)
.containsExactly("nome", "cognome", "età");
}
@Test
@DisplayName("Parsing di campi quoted con virgole")
void testQuotedFieldsWithCommas() throws Exception {
String line = "\"Rossi, Mario\",\"Via Roma, 42\",Milano";
List<String> fields = parser.parseLine(line);
assertThat(fields)
.hasSize(3)
.containsExactly("Rossi, Mario", "Via Roma, 42", "Milano");
}
@Test
@DisplayName("Parsing di doppi apici escapati")
void testEscapedQuotes() throws Exception {
String line = "\"Einstein\",\"Disse: \"\"Dio non gioca a dadi\"\"\"";
List<String> fields = parser.parseLine(line);
assertThat(fields)
.hasSize(2)
.containsExactly("Einstein", "Disse: \"Dio non gioca a dadi\"");
}
@Test
@DisplayName("Gestione campi vuoti")
void testEmptyFields() throws Exception {
String line = "campo1,,campo3,";
List<String> fields = parser.parseLine(line);
assertThat(fields)
.hasSize(4)
.containsExactly("campo1", "", "campo3", "");
}
@Test
@DisplayName("Parsing fallisce con campo quoted non chiuso")
void testUnclosedQuotedField() {
String line = "campo1,\"campo non chiuso,campo3";
assertThatThrownBy(() -> parser.parseLine(line))
.isInstanceOf(RFC4180CSVParser.CSVParseException.class)
.hasMessageContaining("non chiuso");
}
@ParameterizedTest
@CsvSource({
"'a,b,c', 3",
"'a,b,c,d,e', 5",
"'\"a,b\",c', 2",
"'', 1"
})
@DisplayName("Verifica numero campi con diversi input")
void testFieldCount(String input, int expectedCount) throws Exception {
List<String> fields = parser.parseLine(input);
assertThat(fields).hasSize(expectedCount);
}
@Test
@DisplayName("Test di performance su file grande")
@Timeout(5) // Deve completare entro 5 secondi
void testPerformance() throws Exception {
// Crea file di test con 100,000 righe
Path testFile = tempDir.resolve("large.csv");
try (BufferedWriter writer = Files.newBufferedWriter(testFile)) {
writer.write("id,nome,valore,descrizione\n");
for (int i = 0; i < 100_000; i++) {
writer.write(String.format("%d,Nome%d,%.2f,Descrizione %d\n",
i, i, i * 1.5, i));
}
}
// Parsa il file
List<List<String>> records = parser.parseFile(testFile.toString());
assertThat(records).hasSize(100_001); // Include header
}
@Test
@DisplayName("Test integrazione con repository")
void testRepositoryIntegration() throws Exception {
Path csvFile = tempDir.resolve("studenti.csv");
try (BufferedWriter writer = Files.newBufferedWriter(csvFile)) {
writer.write("matricola,nome,cognome,media_voti\n");
writer.write("12345,Mario,Rossi,28.5\n");
writer.write("67890,Luigi,Verdi,25.0\n");
}
StudenteRepository repository = new StudenteCSVRepository(csvFile.toString());
List<StudenteDTO> studenti = repository.findAll();
assertThat(studenti)
.hasSize(2)
.extracting(StudenteDTO::getMatricola)
.containsExactly("12345", "67890");
}
}
Questi test coprono casi normali, edge cases, e verificano il comportamento in presenza di errori. L'uso di test parametrizzati riduce la duplicazione del codice di test.
Le prestazioni del parsing CSV in Java dipendono da diversi fattori. L'uso di BufferedReader con buffer appropriati (tipicamente 8KB-32KB) è fondamentale per ridurre le operazioni di I/O. L'utilizzo di StringBuilder invece di concatenazione di stringhe (+) è essenziale per costruire campi, in quanto la concatenazione crea nuovi oggetti String ad ogni operazione.
Per file molto grandi, considerare l'uso di memory-mapped files attraverso FileChannel e MappedByteBuffer può offrire miglioramenti prestazionali significativi:
import java.nio.*;
import java.nio.channels.FileChannel;
import java.nio.file.*;
public class MemoryMappedCSVParser {
public static void parseWithMemoryMapping(String filename) throws IOException {
try (FileChannel channel = FileChannel.open(
Paths.get(filename), StandardOpenOption.READ)) {
long fileSize = channel.size();
MappedByteBuffer buffer = channel.map(
FileChannel.MapMode.READ_ONLY, 0, fileSize
);
// Parsing diretto dal buffer mappato
StringBuilder field = new StringBuilder();
while (buffer.hasRemaining()) {
char c = (char) buffer.get();
// Logica di parsing...
}
}
}
}
Per applicazioni multi-threaded, considerare l'uso di parsing parallelo dividendo il file in chunk processabili indipendentemente, facendo attenzione a non dividere nel mezzo di un record quoted multi-riga.
L'ecosistema Java per il parsing CSV riflette i valori fondamentali del linguaggio: type safety, robustezza, e pattern enterprise-ready. Apache Commons CSV e OpenCSV rappresentano soluzioni mature e battle-tested che coprono la stragrande maggioranza dei casi d'uso.
La scelta tra implementazione custom e librerie esterne dovrebbe favorire le librerie per applicazioni di produzione, riservando implementazioni custom solo per requisiti estremamente specifici o contesti educativi. L'integrazione con le Streams API e pattern architetturali come Repository e Service Layer permette di costruire applicazioni scalabili e manutenibili.
La comprensione approfondita dei meccanismi di parsing CSV, dalla gestione dello stato attraverso automi a stati finiti alle ottimizzazioni prestazionali, fornisce le basi per affrontare anche i requisiti più complessi e per debuggare efficacemente problemi in produzione.